// 认证服务
import { config } from '@/config/api.js'

const BASE_URL = config.BASE_URL

// Token存储键名
const TOKEN_KEY = 'miniapp_token'
const USER_INFO_KEY = 'miniapp_user_info'
const TOKEN_EXPIRE_KEY = 'miniapp_token_expire'
const WECHAT_USER_INFO_KEY = 'wechat_user_info'

// 认证服务类
class AuthService {
  constructor() {
    this.token = null
    this.userInfo = null
    this.tokenExpire = null
    this.wechatUserInfo = null
    this.loadFromStorage()
  }

  // 从本地存储加载数据
  loadFromStorage() {
    try {
      this.token = uni.getStorageSync(TOKEN_KEY)
      this.userInfo = uni.getStorageSync(USER_INFO_KEY)
      this.tokenExpire = uni.getStorageSync(TOKEN_EXPIRE_KEY)
      this.wechatUserInfo = uni.getStorageSync(WECHAT_USER_INFO_KEY)
    } catch (error) {
      console.error('加载本地存储失败:', error)
    }
  }

  // 保存到本地存储
  saveToStorage() {
    try {
      uni.setStorageSync(TOKEN_KEY, this.token)
      uni.setStorageSync(USER_INFO_KEY, this.userInfo)
      uni.setStorageSync(TOKEN_EXPIRE_KEY, this.tokenExpire)
      uni.setStorageSync(WECHAT_USER_INFO_KEY, this.wechatUserInfo)
    } catch (error) {
      console.error('保存到本地存储失败:', error)
    }
  }

  // 缓存微信侧返回的原始用户信息（头像、昵称等）
  setWechatUserInfo(info) {
    if (!info || typeof info !== 'object') return
    this.wechatUserInfo = {
      ...this.wechatUserInfo,
      ...info
    }
    this.saveToStorage()
  }

  // 清除本地存储
  clearStorage() {
    try {
      uni.removeStorageSync(TOKEN_KEY)
      uni.removeStorageSync(USER_INFO_KEY)
      uni.removeStorageSync(TOKEN_EXPIRE_KEY)
      uni.removeStorageSync(WECHAT_USER_INFO_KEY)
    } catch (error) {
      console.error('清除本地存储失败:', error)
    }
  }

  // 检查token是否有效
  isTokenValid() {
    if (!this.token || !this.tokenExpire) {
      return false
    }
    
    const now = Date.now()
    const expireTime = parseInt(this.tokenExpire)
    
    // 提前5分钟刷新token
    return now < (expireTime - 5 * 60 * 1000)
  }

  // 微信授权登录
  wechatLogin() {
    return new Promise((resolve, reject) => {
      uni.showLoading({
        title: '登录中...',
        mask: true
      })

      // 1. 获取微信授权码
      uni.login({
        provider: 'weixin',
        success: (loginRes) => {
          if (loginRes.code) {
            console.log('获取微信授权码成功:', loginRes.code)
            
            // 2. 调用后端微信登录接口
            uni.request({
              url: BASE_URL + '/api/auth/wechat/login',
              method: 'POST',
              data: {
                code: loginRes.code
              },
              success: (response) => {
                uni.hideLoading()
                
                if (response.data.code === 200) {
                  const { token, expiresIn, userInfo, isNewUser } = response.data.data
                  
                  // 保存认证信息
                  this.token = token
                  this.userInfo = userInfo
                  this.tokenExpire = Date.now() + (expiresIn * 1000)
                  
                  // 保存到本地存储
                  this.saveToStorage()
                  
                  console.log('微信登录成功:', userInfo)
                  
                  // 注意：getUserProfile 已被微信废弃，返回的是假数据
                  // 用户需要通过 chooseAvatar 和 nickname 输入框主动提交头像和昵称
                  // 如果用户信息不完整，会在登录页面引导用户填写
                  
                  // 如果是新用户，提示用户完善信息
                  if (isNewUser) {
                    uni.showToast({
                      title: '欢迎新用户！请完善头像和昵称',
                      icon: 'success',
                      duration: 2000
                    })
                  }
                  
                  resolve(response.data)
                } else {
                  console.error('微信登录失败:', response.data.msg)
                  uni.showToast({
                    title: response.data.msg || '登录失败',
                    icon: 'none'
                  })
                  reject(response.data)
                }
              },
              fail: (error) => {
                uni.hideLoading()
                console.error('微信登录请求失败:', error)
                uni.showToast({
                  title: '网络连接失败',
                  icon: 'none'
                })
                reject(error)
              }
            })
          } else {
            uni.hideLoading()
            console.error('获取微信授权码失败:', loginRes.errMsg)
            uni.showToast({
              title: '获取微信授权失败',
              icon: 'none'
            })
            reject(new Error('获取微信授权码失败'))
          }
        },
        fail: (error) => {
          uni.hideLoading()
          console.error('微信登录失败:', error)
          uni.showToast({
            title: '微信登录失败',
            icon: 'none'
          })
          reject(error)
        }
      })
    })
  }

  // 已废弃：getUserProfile 返回的是假数据，不再使用
  // 新的方式：用户通过 chooseAvatar 和 nickname 输入框主动提交
  // 保存用户选择的头像（从 chooseAvatar 事件获取）
  async saveUserAvatar(avatarUrl) {
    if (!avatarUrl) {
      console.warn('头像URL为空')
      return Promise.reject(new Error('头像URL为空'))
    }
    
    if (!this.userInfo) {
      this.userInfo = {}
    }
    
    this.userInfo.wechatAvatar = avatarUrl
    
    // 保存到本地存储
    this.saveToStorage()
    
    // 同步到后端
    try {
      await this.updateUserInfo({
        wechatAvatar: avatarUrl
      })
      console.log('保存头像成功:', avatarUrl)
      return Promise.resolve()
    } catch (e) {
      console.warn('同步头像到后端失败:', e)
      throw e
    }
  }
  
  // 保存用户输入的昵称（从 nickname 输入框获取）
  async saveUserNickname(nickname) {
    if (!nickname || !nickname.trim()) {
      console.warn('昵称为空')
      return Promise.reject(new Error('昵称为空'))
    }
    
    if (!this.userInfo) {
      this.userInfo = {}
    }
    
    this.userInfo.wechatNickname = nickname.trim()
    
    // 保存到本地存储
    this.saveToStorage()
    
    // 同步到后端
    try {
      await this.updateUserInfo({
        wechatNickname: nickname.trim()
      })
      console.log('保存昵称成功:', nickname)
      return Promise.resolve()
    } catch (e) {
      console.warn('同步昵称到后端失败:', e)
      throw e
    }
  }
  
  // 批量更新用户信息（头像和昵称一起更新）
  async saveUserProfile(avatarUrl, nickname) {
    if (!avatarUrl && !nickname) {
      console.warn('头像和昵称都为空')
      return
    }
    
    if (!this.userInfo) {
      this.userInfo = {}
    }
    
    const updateData = {}
    
    if (avatarUrl) {
      this.userInfo.wechatAvatar = avatarUrl
      updateData.wechatAvatar = avatarUrl
    }
    
    if (nickname && nickname.trim()) {
      this.userInfo.wechatNickname = nickname.trim()
      updateData.wechatNickname = nickname.trim()
    }
    
    // 保存到本地存储
    this.saveToStorage()
    
    // 同步到后端
    try {
      await this.updateUserInfo(updateData)
      console.log('保存用户信息成功:', updateData)
    } catch (e) {
      console.warn('同步用户信息到后端失败:', e)
      throw e
    }
  }

  // 合并微信头像昵称到本地用户信息（仅使用已存储的信息，不主动调用 getUserProfile）
  // 注意：requestWechatUserProfile() 必须在用户点击事件中调用
  async ensureWechatProfileMerged() {
    try {
      const needNickname = !this.userInfo || !this.userInfo.wechatNickname
      const needAvatar = !this.userInfo || !this.userInfo.wechatAvatar
      if (!needNickname && !needAvatar) return
      
      // 只使用已存储的微信信息，不主动调用 getUserProfile（必须在用户点击时调用）
      const wechat = this.wechatUserInfo
      if (!wechat) {
        // 没有已存储的微信信息，直接返回（需要用户主动点击获取）
        return
      }
      
      if (!this.userInfo) this.userInfo = {}
      this.userInfo.wechatNickname = this.userInfo.wechatNickname || wechat.nickName
      this.userInfo.wechatAvatar = this.userInfo.wechatAvatar || wechat.avatarUrl
      this.userInfo.wechatGender = this.userInfo.wechatGender || (wechat.gender != null ? String(wechat.gender) : undefined)
      this.userInfo.wechatProvince = this.userInfo.wechatProvince || wechat.province
      this.userInfo.wechatCity = this.userInfo.wechatCity || wechat.city
      this.userInfo.wechatCountry = this.userInfo.wechatCountry || wechat.country
      this.saveToStorage()
      
      try {
        await this.updateUserInfo({
          wechatNickname: this.userInfo.wechatNickname,
          wechatAvatar: this.userInfo.wechatAvatar,
          wechatGender: this.userInfo.wechatGender,
          wechatProvince: this.userInfo.wechatProvince,
          wechatCity: this.userInfo.wechatCity,
          wechatCountry: this.userInfo.wechatCountry
        })
      } catch (e) {
        console.warn('同步微信资料到后端失败（忽略）:', e)
      }
    } catch (err) {
      console.warn('合并微信资料失败（忽略）:', err)
    }
  }

  // 更新用户信息到后端
  async updateUserInfo(userInfo) {
    return new Promise((resolve, reject) => {
      console.log('开始更新用户信息到后端:', userInfo)
      uni.request({
        url: BASE_URL + '/api/auth/wechat/updateUserInfo',
        method: 'POST',
        header: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer ' + this.token
        },
        data: userInfo,
        success: (response) => {
          console.log('后端更新用户信息响应:', response.data)
          if (response.data.code === 200) {
            console.log('更新用户信息成功')
            // 保存成功后，更新本地用户信息
            if (this.userInfo) {
              if (userInfo.wechatAvatar) {
                this.userInfo.wechatAvatar = userInfo.wechatAvatar
              }
              if (userInfo.wechatNickname) {
                this.userInfo.wechatNickname = userInfo.wechatNickname
              }
              // 保存到本地存储
              this.saveToStorage()
              console.log('本地用户信息已更新:', this.userInfo)
            }
            resolve(response.data)
          } else {
            console.error('更新用户信息失败:', response.data.msg)
            reject(response.data)
          }
        },
        fail: (error) => {
          console.error('更新用户信息请求失败:', error)
          reject(error)
        }
      })
    })
  }

  // 小程序登录（保留原有方法，用于兼容）
  async miniappLogin() {
    return new Promise((resolve, reject) => {
      uni.showLoading({
        title: '登录中...',
        mask: true
      })

      uni.request({
        url: BASE_URL + '/api/auth/miniapp/login',
        method: 'POST',
        data: {
          username: 'admin',
          password: 'admin123'
        },
        success: (response) => {
          uni.hideLoading()
          
          if (response.data.code === 200) {
            const { token, expiresIn, userInfo } = response.data.data
            
            // 保存认证信息
            this.token = token
            this.userInfo = userInfo
            this.tokenExpire = Date.now() + (expiresIn * 1000)
            
            // 保存到本地存储
            this.saveToStorage()
            
            console.log('登录成功:', userInfo)
            resolve(response.data)
          } else {
            console.error('登录失败:', response.data.msg)
            uni.showToast({
              title: response.data.msg || '登录失败',
              icon: 'none'
            })
            reject(response.data)
          }
        },
        fail: (error) => {
          uni.hideLoading()
          console.error('登录请求失败:', error)
          uni.showToast({
            title: '网络连接失败',
            icon: 'none'
          })
          reject(error)
        }
      })
    })
  }

  // 刷新token
  async refreshToken() {
    // 这里可以实现token刷新逻辑
    // 如果后端支持refresh token，可以调用刷新接口
    // 否则重新登录
    return this.wechatLogin()
  }

  // 获取有效的token
  async getValidToken() {
    if (this.isTokenValid()) {
      return this.token
    }
    
    // token无效，尝试刷新
    try {
      await this.refreshToken()
      return this.token
    } catch (error) {
      console.error('刷新token失败:', error)
      throw new Error('认证失败，请重新登录')
    }
  }

  // 退出登录
  logout() {
    this.token = null
    this.userInfo = null
    this.tokenExpire = null
    this.wechatUserInfo = null
    this.clearStorage()
    
    // 清除首次启动标记，下次启动需要重新授权
    uni.removeStorageSync('isFirstLaunch')
    
    uni.showToast({
      title: '已退出登录',
      icon: 'success'
    })
  }

  // 获取用户信息
  getUserInfo() {
    return this.userInfo
  }

  // 获取已存储的微信用户信息（不弹窗）
  getWechatUserInfo() {
    return this.wechatUserInfo
  }

  // 检查是否已登录
  isLoggedIn() {
    return this.isTokenValid()
  }
}

// 创建单例实例
const authService = new AuthService()

export default authService
